Линейные уравнения и матрицы

Решение систем линейных алгебраических уравнений

Функция LinearSolve(m, b, meth, fr, conj, in, opts, mopts) по матрице коэффициентов m размером p´q и вектору свободных членов b длины p решает систему линейных алгебраических уравнений вида m.x = b, где x – вектор столбец неизвестных длины q. Элементы m и компоненты b могут быть числовыми и (или) символьными величинами. В результате вычислений или возвращается вектор столбец решений, возможно со свободными переменными, или сообщение о несовместности системы, то есть об отсутствии решений.

Из курса алгебры известна следующая теорема Кронекера-Капелли. Система линейной алгебраических уравнений m.x = b совместна тогда и только тогда, когда ранг матрицы m равен рангу расширенной матрицы m | b. Здесь m | b – это <<m> | <b>>, то есть присоединение вектора b справа к m.

Матричное уравнение m.x = b соответствует записи системы в форме:

(1)

Все аргументы в LinearSolve, кроме первого, не являются обязательными. При отсутствии b первые q–1 столбцов m задают матрицу коэффициентов системы, а последний q-й столбец m – вектор свободных членов. Если b есть матрица размера p´r, то одновременно решаются r систем вида m.Column(b, k) (k = 1, 2, …, r). При этом ответ формируется в виде матрицы размером p´r, в которой k-й столбец является решением k-й системы. Остальные аргументы имеют следующий смысл:

· meth – опция, записываемая в виде method = na, где na Î {none, solve, subs, Cholesky, LU, QR, hybrid, SparseLU, SparseDirect и SparseIterative}. Значение na задает метод решения системы (1). По умолчанию метод выбирается системой в зависимости от формы m и типа ее элементов.

· fr – опция, записываемая в виде free = name, где name имя для возможных свободных переменных системы. По умолчанию это _t1 (или _t2, или _t3, …);

· conj – опция, записываемая в виде conjugate = lo, где lo Î {true, false}. В декомпозиционных методах Cholesky и QR при lo = true и при отсутствии опции conj используется эрмитово сопряжение, а иначе – транспонирование;

· in – опция, записываемая в виде inplace = lo, где lo Î {true, false}. При lo = true результат формируется на месте свободного члена b. При lo = false и при отсутствии опции in вычисления не затрагивают исходных данных. Во избежание потерь данных опция должна использоваться осторожно. Кроме того, при lo = true нельзя использовать аргумент opts;

· opts – конструктор опций результата;

· mopts – опция, записываемая в виде methodoptions = li. Элементы списка li задают опции, контролирующие используемый метод. Пока этот аргумент работает только для метода SparseIterative.

Примеры 1. Решение систем линейных алгебраических уравнений.

>	m := Matrix([[a, b], [c, d]]): # с символьными	{Shift+¿}
	r := Vector([g, h]): # элементами	{Shift+¿}
	s := LinearSolve(m, r):	{Shift+¿}
	m, r, Transpose(s);	{¿}
>	m := Matrix([[1, 5], [2, 4]]): # две системы	{Shift+¿}
	b := Matrix([[11, 1], [10, 2]]):	{Shift+¿}
	s := LinearSolve(m, b):	{Shift+¿}
	m, b, s;	{¿}
>	seq(m.Column(s, k) = Column(b, k), k = 1..2);	{¿}
>	m := Matrix([[1, 5, 2], [-2, 4, 7]]): # p < q	{Shift+¿}
	b := Vector([2, 3]):	{Shift+¿}
	s1 := LinearSolve(m, b):	{Shift+¿}
	s2 := LinearSolve(m, b, free = x): m, b, s1, s2;	{¿}
>	m.s1-b, m.s2-b;	{¿}
>	m := Matrix([[1, 6], [1, -3], [2, 3]]): # p > q	{Shift+¿}
	b := Vector([8, -1, 7]):	{Shift+¿}
	r1 := Rank(m): r2 := Rank(<<m> | <b>>):	{Shift+¿}
	s := LinearSolve(m, b, inplace):	{Shift+¿}
	r1, r2, map(Transpose, [s, b]);	{¿}
>	m := Matrix([[1, 6, 8], [1, -3, -1]]): # b опущено	{Shift+¿}
	s := LinearSolve(m): m, s;	{¿}
>	pr1 := DeleteColumn(m, 3).s-Column(m, 3):	{Shift+¿}
	pr2 := DeleteColumn(m, -1).s-Column(m, -1):	{Shift+¿}
	pr3 := SubMatrix(m, 1..2, 1..2).s-Column(m, 3):	{Shift+¿}
	pr4 := SubMatrix(m, 1..-1, 1..-2).s-Column(m, 3):	{Shift+¿}
	pr5 := m[1..-1, 1..-2].s-Column(m, -1):	{Shift+¿}
	pr1, pr2, pr3, pr4, pr5;	{¿}
>	m := Matrix([[1, 6], [1, -3]]): # замещение b	{Shift+¿}
	b := Vector([8, -1]):	{Shift+¿}
	s := LinearSolve(m, b, inplace): s, b;	{¿}

Генерирование уравнений и матриц

Функция GenerateEquations(m, v, b) по матрице коэффициентов m размером p´q, вектору столбцу имен переменных v длины q и вектору столбцу свободных членов b длины p генерирует список линейных алгебраических уравнений (1). Аргумент b необязателен.

При отсутствии b и длине v, равной q, генерируется список из уравнений системы вида m.v = ZeroVector(p).

При отсутствии b и длине v, равной q–1, генерируется список из уравнений системы вида m[1..-1, 1..-2].v = m[1..-1,-1]. Иными словами, первые q–1 столбцов m задают матрицу коэффициентов системы, а последний q-й столбец m – вектор свободных членов.

Функция GenerateMatrix(eqns, v, aug, opts) по списку или множеству линейных алгебраических уравнений eqns и списку или множеству имен переменных v возвращает матрицу коэффициентов m соответствующей системы уравнений и ее вектор столбец свободных членов b. Уравнения в списке eqns вида a = 0 можно задавать их левой частью a. Аргументы aug и opts в A необязательны, а смысл их следующий:

· aug – опция вида augmented = lo, где lo Î {true, false}. Она определяет вид формируемого результата. При отсутствии опции aug и при lo = false результат возвращается в виде последовательности m, b, а при lo = true и при заданиии aug словом augmented – в виде m | b (<<m> | <b>>), то есть в форме присоединения вектора b справа к m.

· opts – конструктор опций результата:

Примеры 2. Генерирование систем линейных алгебраических уравнений по матрице коэффициентов и вектору свободных членов. Формирование матрицы коэффициентов и вектора свободных членов по системе линейных алгебраических уравнений.

>	m := Matrix([[1, 3, 2], [2, -4, 5]]):	{Shift+¿}
	va := [x, y, z]: b := Vector([13, 7]):	{Shift+¿}
	m, va, b;	{¿}
>	eq := GenerateEquations(m, va, b);	{¿}
>	LinearSolve(m, b, free = w), solve(eq, va);	{¿}
>	tt := solve(eq, va): tt[1]; op(tt); op(tt[1]);	{¿}
>	w := [w1, w2, w3]: eqns := GenerateEquations(m, w, b);	{¿}
>	GenerateMatrix(eqns, w), GenerateMatrix(eqns, w, augmented);	{¿}
>	eq := [a1*x+a2*y+a3*z = f, a2*x+a3*y+a1*z = g]:	{Shift+¿}
	GenerateMatrix(eq, [x, y, z]), GenerateMatrix(eq, [a1, a2, a3]);	{¿}

Гауссовы исключения. Приведение матрицы к ступенчатому виду

Функция GaussianElimination(m) для прямоугольной матрицы m с числовыми или символьными элементами, возвращает верхнюю треугольную матрицу U того же размера, что и m. Вычисления реализуются исключениями Гаусса. Выполнение функции равносильно декомпозиции LUDecomposition(m, output = [U]), то есть выводу верхней треугольной матрицы U в PLU-разложении m.

Функция GaussianElimination(m, me, opts) выполняется аналогично со следующими изменениями и дополнениями, специфицируемыми необязательными аргументами me и opts:

· me – опция, задающая используемый метод, и, записываемая в виде method = na, где na Î {GaussianElimination, FractionFree};

· opts – конструктор опций результата;

Функция ReducedRowEchelonForm(m) для прямоугольной матрицы m с числовыми или символьными элементами возвращает ее верхнюю ступенчатую форму R. Вычисления реализуются исключениями Гаусса-Жордана. Выполнение C равносильно декомпозиции LUDecomposition(m, output = [R]), то есть выводу верхней ступенчатой матрицы R в PLU1R-разложении m.

Заметим, что при исключениях Гаусса подстановки реализуются во все строки с номерами большими номера текущей (ведущей) строки, а при исключениях Гаусса-Жордана – во все строки, кроме текущей строки.

Функция BackwardSubstitute(m, b, fr, in, opts) решает систему линейных алгебраических уравнений m.x = b с верхней ступенчатой матрицей m размером p´q и вектором b длины q. Если b – матрица размером q´t, то одновременно решается t систем, свободные члены которых есть столбцы b. Если b не задано, то решается система SubMatrix(m, 1..-1, 1..-2).x = SubMatrix(m, 1..-1, -1). Необязательные аргументы fr, in и opts имеют тот же смысл, что и одноименные аргументы функции LinearSolve.

Функция ForwardSubstitute(m, b, fr, in, opts) выполняется аналогично, но здесь m – нижняя ступенчатая матрица.

Примеры 3. Гауссовы исключения и приведение матрицы к ступенчатой форме.

>	m := Matrix([[2, t, 1], [2, 1, -1], [8, 2, -1]]):	{Shift+¿}
	a := GaussianElimination(m):	{Shift+¿}
	b := LUDecomposition(m, output = [U]):	{Shift+¿}
	m, a, b-a;	{¿}
>	m := Matrix([[7, 0, 7, 8, 1], [16, 0, 16, 3, 13],	{Shift+¿}
	[9, 4, 1, 6, 12], [7, -4, 15, -3, 1]]):	{Shift+¿}
	Rank(m), m, GaussianElimination(m);	{¿}
>	s := ReducedRowEchelonForm(m):	{Shift+¿}
	b := LUDecomposition(m, output = [R]): s, b-s;	{¿}
>	Transpose(BackwardSubstitute(s, free = x));	{¿}

Метод наименьших квадратов

Функция LeastSquares(m, b, optim, fr, conj, opts) методом наименьших квадратов решает одну или несколько систем линейных алгебраических уравнений вида n.x = c, где n – матрица размером p´q, а с – вектор-столбец длины p. Если de = n.x–c, то отыскивается такой вектор x длины q, для которого величина нормы

Norm(de, 2) = VectorNorm(de, 2) =

принимает наименьшее значение. При отсутствии комплексных элементов в n и c норма вычисляется как sqrt(add(de[k]², k = 1..p)).

Аргументы имеют следующий смысл:

· m – матрица размером p´q или множенство из p линейных уравнений с q неизвестными. В последнем случае b должно быть множеством с q неизвестными;

· b – вектор-столбец, матрица или множество. Если b – вектор длины p, то решается одна система m.x = b. Если b – матрица размером p´s, то решается s систем вида m.x = b[1..-1, k] (k = 1, 2, …, s). Если b – множество из q неизвестных, то решается система с этими неизвестными, заданная множеством уравнений m;

· optim – необязательная опция, специфицирующая оптимизацию в случае, когда получено параметризованное решение задачи. Записывается опция в виде optimize = lo, где lo Î {true, false}. При lo = true и при задании опции optim словом optimize возвращается такое решение x, для которого минимальна норма Norm(x, 2). При отсутствии опции optim и при lo = false решение возвращается в общем виде;

· fr – необязательная опция, задающая имя свободных переменных в параметризованном решении задачи. Записывается опция в виде free = NoUserValue или free = na, где na – имя переменной. При free = na используется переменная na, а во всех остальных случаях – переменная _t#, где # – пусто или целое число;

· conj – необязательная опция, специфицирующая использование при нахождении решения эрмитова сопряжения. Записывается она в виде conjugate = lo, где lo Î {true, false}. При отсутствии опции conj, при lo = true и при записи опции словом conjugate используется эрмитово сопряжение. При lo = false используется обычное транспонирование матриц;

· opts – конструктор опций результата;

Отметим, что для матриц m с элементами типа float или complex при p > q решение ищется с помощью QR-декомпозиции, а при p < q – с помощью сингулярной декомпозиции. Во всех иных случаях поиск решения проводится с использованием нормальной системы уравнений.

Примеры 4. Решение систем линейных алгебраических уравнений методом наименьших квадратов.

>	m := Matrix([[1, 6], [2, 1], [3, -1]]): b := Vector([2, 1, 3]):	{Shift+¿}
	x := LeastSquares(m, b): z := m.x-b:	{Shift+¿}
	'm' = m, 'b' = b, 'x' = x;	{¿}
>	de := Transpose(abs((evalf[5])(z))):	{Shift+¿}
	'de' = de, evalf[5](sqrt(z[1]^2+ z[2]^2+z[3]^2));	{¿}
>	no1 := evalf[9](Norm(z, 2)): no2 := evalf[9](VectorNorm(z, 2)):	{Shift+¿}
	'no1' = no1, 'no2' = no2;	{¿}
>	m := Matrix([[1, 6, 5, 1], [2, 1, 9, 3], [3, -1, 1, 2]]):	{Shift+¿}
	b := Vector([2, 1, 3]): m, b;	{¿}
>	x := LeastSquares(m, b):	{Shift+¿}
	Transpose(x), Transpose(m.x-b);	{¿}
>	y := LeastSquares(m, b, optimize):	{Shift+¿}
	Transpose(y), Norm(y, 2), evalf[3](Norm(y, 2));	{¿}

Декомпозиция матриц

PLU-декомпозиция, PLU1R- декомпозиция, декомпозиция Холецкого

Функция LUDecomposition(m) для матрицы m вычисляет ее PLU-декомпозицию (факторизацию, разложение), возвращая последовательность из трех матриц P, L и U таких, что m = P.L.U, где:

· P – матрица перестановок размером p´p. Произведение L.U имеет те же самые строки, что и m, но порядок их расположения может быть иным. Домножая P слева на L.U мы получает в точности матрицу m;

· L – нижняя треугольная матрица размером p´p с единичными элементами на главной диагонали;

· U – верхняя треугольная матрица размером p´q.

Функция LUDecomposition(m, method = RREF) для матрицы m вычисляет PLU1R-декомпозицию, возвращая последовательность из четырех матриц P, L, U1 и R таких, что m = P.L.U1.R, где:

· P, L – такие же матрицы, как и в PLU-декомпозиции m;

· U1 – верхняя треугольная матрица размером p´p;

· R – верхняя треугольная ступенчатая матрица размером p´q, причем U1.R = U, где U – соответствующая матрица из PLU-декомпозиции m.

Результаты вычислений по B и по LUDecomposition(m, output = ['P', 'L', 'U1', 'R']) одинаковы.

Функция LUDecomposition(m, method = Cholesky). Предполагается, что в данном случае m квадратная эрмитова положительно определенная матрица. Тогда вычисляется декомпозиция Холецкого матрицы m и возвращается нижняя треугольная матрица L с неотрицательными диагональными элементами такая, что m = L.L^* (L^* = HermitianTranspose(L)). При этом L^* является положительно определенной матрицей.

Функция LUDecomposition(m, me, out, conj, in, opts) является расширением функций для вычисления PLU-декомпозиции, PLU1R-декомпозиции или декомпозиции Холецкого. Смысл ее аргументов от второго и далее следующий:

· me – опция, записываемая в виде method = na, где na Î {GaussianElimination, RREF, FractionFree, Cholesky, none}. Значение na задает метод декомпозиции (факторизации) m. По умолчанию используется метод none, эквивалентный методу GaussianElimination;

· out – опция, записываемая в виде output = obj, где obj Î {'P', 'L', 'U', 'U1', 'R', 'NAG', 'determinant', 'rank'}. Значение obj указывает возвращаемый объект. Списком можно задать несколько таких объектов. Возвращаться они будут в порядке следования в списке. Поместить 'U' в список вместе с 'U1' или 'R' нельзя. Объект rank инициирует вывод ранга матрицы m. Объект 'determinant' для квадратной матрицы m инициирует вывод определителя m.

Объект 'NAG' может быть задан или один, или вместе с объектами rank и (или) determinant. Он реализует компактную форму вывода матриц P, L и U, упаковывая их в вектор-столбец X длины s = min(p, q) и в матрицу Y размером p´q. Причем в левую нижнюю часть Y помещается заведомо ненулевая часть L без единичных диагональных элементов. В остальной части Y располагается заведомо ненулевая часть U. Вектор X = (x₁, x₂, …, x_s) таков, что его элементы x_k (k = 1, 2, …, s) задают последовательные транспозиции в перестановке a = (1, 2, …, p). А именно, x₁ предписывает поменять местами в a элементы в позициях 1 и x₁, x₂ предписывает поменять местами в полученной перестановке элементы в позициях 2 и x₂ и т. д. В результате таких действий a преобразуется в перестановку b = (b_1, b₂, …, b_p), по которой однозначно восстанавливается P: единицы в P стоят в позициях (b_k, k) (k = 1, 2, …, p), а остальные элементы P – нули (см. пример 39);

· conj – опция, записываемая в виде conjugate = lo, где lo Î {true, false}. Она используется только в случае декомпозиции Холецкого. При отсутствии опции conjugate и при lo = true при вычислениях используется эрмитово сопряжение, а при lo = false – обычное транспонирование;

· in – опция, записываемая в виде inplace = lo, где lo Î {true, false}. Она используется только при наличии в списке вывода объектов U или NAG. При lo = true и при опции in, заданной одним словом inplace, результат вычислений замещает первый аргумент. При lo = false и при отсутствии опции in исходные данные не изменяются. Опции in и opts не совместимы друг с другом;

· opts – конструктор опций результата. Аргумент opts записывается в виде outputoptions[obj] = li, где obj Î {'P', 'L', 'U', 'U1', 'R', 'NAG'}, li – список опций.

Примеры 5. Вычисление для матриц PLU-декомпозиции, PLU1R-декомпозиции и декомпозиции Холецкого.

>	# PLU-декомпозиция	{Shift+¿}
	m := Matrix([[2, 1, 1, 7], [2, 1, -1, 0], [8, 2, -1, 3]]):	{Shift+¿}
	P, L, U := LUDecomposition(m);	{¿}
>	m, P.L.U;	{¿}
>	LUDecomposition(m, output = ['NAG', rank]);	{¿}
>	# PLU1R-декомпозиция	{Shift+¿}
	LUDecomposition(m, method = RREF);	{¿}
>	P, L, U1, R := LUDecomposition(m, output = ['P', 'L', 'U1', 'R']);	{¿}
	P, L, U1, R := те же матрицы, что и при method = RREF
>	Equal(m, P.L.U1.R), Equal(U, U1.R);	{¿}
>	# декомпозиция Холецкого	{Shift+¿}
	h := Matrix([[4, 1, 3], [1, 4, 1], [3, 1, 6]]):	{Shift+¿}
	h, IsDefinite(h);	{¿}
	L := LUDecomposition(h, method = Cholesky):	{Shift+¿}
	H := HermitianTranspose(L): L, L.H, IsDefinite(H);	{¿}

Примеры 6. Написать процедуру plufromnag, которая по матрице m вычисляет ее PLU-декомпозицию в форме NAG и без использоваия функций A-D формирует и возвращает матрицы P, L и U так, как они представлены в обычной “распакованной” PLU-декомпозиции m.

Решение. Ниже приведен один из возможных вариантов решения поставленной задачи и реализованы вычисления для трех контрольных примеров.

>	restart: with(LinearAlgebra):	{¿}
>	plufromnag := proc(m)	{Shift+¿}
	local v, nag, p, q, i, j, w, r, P, L, U;	{Shift+¿}
	v, nag := LUDecomposition(m, output = 'NAG');	{Shift+¿}
	p, q := Dimension(nag): # формирование L	{Shift+¿}
	L := Matrix(p): for j from 1 to p do L[j, j] := 1 end do;	{Shift+¿}
	for i from 1 to p do for j from 1 to min(i, q)-1 do	{Shift+¿}
	L[i, j] := nag[i, j];	{Shift+¿}
	end do: end do;	{Shift+¿}
	U := Copy(nag); # формирование U	{Shift+¿}
	for i from 2 to p do for j from 1 to min(i-1, q) do	{Shift+¿}
	U[i, j] := 0;	{Shift+¿}
	end do: end do;	{Shift+¿}
	P := Matrix(p): w := <seq(j, j = 1..p)>; # формирование P	{Shift+¿}
	for i from 1 to Dimension(v) do	{Shift+¿}
	j := v[i]: r := w[i]: w[i] := w[j]: w[j] := r;	{Shift+¿}
	end do;	{Shift+¿}
	for j from 1 to p do P[w[j], j]:=1 end do;	{Shift+¿}
	end proc:	{¿}
>	# вычисления по процедуре plufromnag	{¿}
	m := Matrix([[1, 2], [4, 5]]): # 1	{Shift+¿}
	P, L, U := plufromnag(m): m, P, L, U, Equal(P.L.U, m);	{¿}
>	m := Matrix([[1, 2, 3], [4, 5, 6]]): #2	{Shift+¿}
	P, L, U := plufromnag(m): m, P, L, U, Equal(P.L.U, m);	{¿}
>	m := Matrix([[1, 2, 3], [4, 5, 6], [8, 5, 2], [2, 7, 5]]): #3	{Shift+¿}
	P, L, U := plufromnag(m): m, P, L, U;	{¿}

QR-декомпозиция

Функция QRDecomposition(m, fs, out, conj, opts, …). Напомним, что ранг матрицы m называется полным, если он равен минимальному значению из числа строк и числа столбцов m. По A реализуется QR-декомпозиция матрицы m размером p´q с числовыми или символьными элементами. Аргументы от второго и далее необязательны и имеют следующий смысл:

· fs – опция, записываемая в виде fullspan = lo, где lo Î {true, false}. В случае если lo = true, или fs задана одним словом fullspan, или m имеет полный ранг, то проводится полное QR-разложение m. То есть, возвращается последовательность из унитарной матрицы Q размером p´p и верхней треугольной матрицы R размером p´q, причем m = Q.R, а унитарность Q означает, что Q.HermitianMatrix(Q) = IdentityMatrix(p). В случае если ранг r матрицы m не является полным, и опция fs отсутствует или lo = false, то проводится так называемое неполное Q1R1 разложение m. То есть, возвращается последовательность из матрицы Q1 размером p´r и верхней треугольной матрицы R1 размером r´q, причем m = Q1.R1;

· out – опция, специфицирующая вычисляемые объекты и порядок их вывода. Записывается она в виде output = obj, где obj принадлежит множеству {Q, R, NAG, rank} или является списком некоторых элементов этого множества. Значение NAG инициирует вывод Q и R в специальном формате и используется только тогда, когда элементы m заданы в плавающей форме;

· conj – опция, специфицирующая при нахождении QR-декомпозиции использование эрмитова сопряжения. Записывается она в виде conjugate = lo, где lo Î {true, false}. При отсутствии опции conj, при lo = true и при записи опции одним словом conjugate используется эрмитово сопряжение. При lo = false используется обычное транспонирование матриц;

· opts – конструктор опций результата, записываемый в виде outputoptions[o] = li, где o Î {Q, R, NAG} и li – список опций.

Примеры 7. QR-декомпозиция матриц.

>	m := Matrix([[1, 2, 1, 1], [0, 1, 2, 1], [1, 0, 0, 2]]): m, Rank(m);	{Shift+¿}
	Q, R := QRDecomposition(m);	{¿}
>	Equal(Q.R, m), Q.HermitianTranspose(Q);	{¿}
>	m := Matrix([[1, 2, 1, 1], [0, 1, 2, 1], [1, 3, 3, 2]]):	{Shift+¿}
	Q, R, r := QRDecomposition(m, fullspan, output = [Q, R, rank]);	{Shift+¿}
	r, Q.R-m, Q.HermitianTranspose(Q);	{¿}

Приведение квадратной матрицы к Жордановой форме

Функция JordanForm(m, out, opts)

Примеры 8.

>	li := [[8/3, -5/3, 0], [4/15, 74/15, 9/5], [-8/15, 2/15, 7/5]]:	{Shift+¿}
	m := Matrix(li): Q, J := JordanForm(m, output = ['Q', 'J']):	{Shift+¿}
	m, Q, J;	{¿}
>	Equal(MatrixInverse(Q).m.Q, J);	{¿}
>	Equal(Q.J.MatrixInverse(Q), m);	{¿}

Задания:

1. Решить систему линейных уравнений матричным способом. Предусмотреть проверку на невырожденность матрицы А. Генерацию элементов матриц A и B осуществить с использованием генератора случайных чисел.

2. Решить систему линейных алгебраических уравнений методом Крамера. Генерацию элементов матриц A и B осуществить с использованием генератора случайных чисел.

3. Решить систему линейных алгебраических уравнений методом исключения неизвестных (Гаусса). Генерацию элементов матриц A и B осуществить с использованием генератора случайных чисел.